const express = require('express');
const cors = require('cors');
const path = require('path');
const WebSocket = require('ws');
const OpenAI = require('openai');
const axios = require('axios');
require('dotenv').config({ path: './config.env' });

const app = express();
const PORT = process.env.PORT || 3000;

// 中间件
app.use(cors());
app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

// 模型配置
const MODEL_CONFIG = {
  openai: {
    name: 'OpenAI GPT-4',
    client: new OpenAI({
      apiKey: process.env.OPENAI_API_KEY,
    }),
    model: 'gpt-4',
    maxTokens: 500,
    temperature: 0.8
  },
  moonshot: {
    name: 'Moonshot Kimi',
    apiKey: process.env.MOONSHOT_API_KEY,
    baseURL: 'https://api.moonshot.cn/v1',
    model: 'moonshot-v1-8k',
    maxTokens: 500,
    temperature: 0.8
  },
  deepseek: {
    name: 'DeepSeek Chat',
    apiKey: process.env.DEEPSEEK_API_KEY,
    baseURL: 'https://api.deepseek.com/v1',
    model: 'deepseek-chat',
    maxTokens: 500,
    temperature: 0.8
  },
  zhipu: {
    name: '智谱AI GLM-4',
    apiKey: process.env.ZHIPU_API_KEY,
    baseURL: 'https://open.bigmodel.cn/api/paas/v4',
    model: 'glm-4',
    maxTokens: 500,
    temperature: 0.8
  }
};

// 当前使用的模型
const CURRENT_MODEL = process.env.CURRENT_MODEL || 'moonshot';

// AI角色配置
const AI_ROLES = {
  'socrates': {
    name: '苏格拉底',
    description: '古希腊哲学家，以苏格拉底式提问法闻名',
    systemPrompt: `你是苏格拉底，古希腊最著名的哲学家之一。你的特点是：
1. 使用苏格拉底式提问法，通过连续的问题引导学生思考
2. 承认自己的无知（"我知道我一无所知"）
3. 关注道德、正义、真理等哲学问题
4. 用简单的问题引出深刻的思考
5. 语言风格：温和、智慧、富有启发性

请始终保持苏格拉底的角色特征，用中文与用户对话。`,
    skills: ['哲学问答', '苏格拉底式提问', '道德讨论', '逻辑推理']
  },
  'harry_potter': {
    name: '哈利·波特',
    description: '魔法世界的救世主，霍格沃茨的学生',
    systemPrompt: `你是哈利·波特，来自J.K.罗琳的《哈利·波特》系列。你的特点是：
1. 勇敢、善良、有正义感
2. 对魔法世界充满好奇和热情
3. 经历过与伏地魔的斗争
4. 了解霍格沃茨、魁地奇、魔法咒语等
5. 语言风格：年轻、热情、有时有些紧张

请始终保持哈利·波特的角色特征，用中文与用户对话。`,
    skills: ['魔法知识', '魁地奇介绍', '霍格沃茨生活', '冒险故事']
  },
  'shakespeare': {
    name: '莎士比亚',
    description: '英国文学巨匠，戏剧和诗歌大师',
    systemPrompt: `你是威廉·莎士比亚，英国文艺复兴时期的伟大剧作家和诗人。你的特点是：
1. 精通英语文学和戏剧
2. 善于用优美的语言表达深刻的思想
3. 了解人性、爱情、权力等永恒主题
4. 有时会用古英语或诗意的表达
5. 语言风格：优雅、深刻、富有诗意

请始终保持莎士比亚的角色特征，用中文与用户对话，但可以适当引用英文原文。`,
    skills: ['文学创作', '戏剧指导', '诗歌欣赏', '英语学习']
  },
  'einstein': {
    name: '爱因斯坦',
    description: '理论物理学家，相对论之父',
    systemPrompt: `你是阿尔伯特·爱因斯坦，20世纪最伟大的物理学家之一。你的特点是：
1. 对物理学有深刻的理解，特别是相对论和量子力学
2. 善于用简单的比喻解释复杂的科学概念
3. 对宇宙、时间、空间有独特的见解
4. 幽默、谦逊，有时会开玩笑
5. 语言风格：智慧、幽默、富有想象力

请始终保持爱因斯坦的角色特征，用中文与用户对话。`,
    skills: ['物理知识', '科学解释', '宇宙探索', '创新思维']
  }
};

// 存储对话历史
const conversations = new Map();

// 通用聊天API调用函数
async function callChatAPI(messages, modelType = CURRENT_MODEL) {
  const config = MODEL_CONFIG[modelType];
  if (!config) {
    throw new Error(`不支持的模型类型: ${modelType}`);
  }

  try {
    if (modelType === 'openai') {
      //  API调用
      const completion = await config.client.chat.completions.create({
        model: config.model,
        messages: messages,
        max_tokens: config.maxTokens,
        temperature: config.temperature,
      });
      return completion.choices[0].message.content;
    } else {
      // 其他模型API调用
      const response = await axios.post(`${config.baseURL}/chat/completions`, {
        model: config.model,
        messages: messages,
        max_tokens: config.maxTokens,
        temperature: config.temperature,
      }, {
        headers: {
          'Authorization': `Bearer ${config.apiKey}`,
          'Content-Type': 'application/json'
        }
      });
      return response.data.choices[0].message.content;
    }
  } catch (error) {
    console.error(`模型 ${modelType} 调用失败:`, error.response?.data || error.message);
    throw new Error(`模型调用失败: ${error.response?.data?.error?.message || error.message}`);
  }
}

// 获取可用模型列表
app.get('/api/models', (req, res) => {
  const availableModels = Object.keys(MODEL_CONFIG).map(key => ({
    id: key,
    name: MODEL_CONFIG[key].name,
    isActive: key === CURRENT_MODEL
  }));
  res.json({
    models: availableModels,
    current: CURRENT_MODEL
  });
});

// 获取角色列表
app.get('/api/roles', (req, res) => {
  const roles = Object.keys(AI_ROLES).map(key => ({
    id: key,
    name: AI_ROLES[key].name,
    description: AI_ROLES[key].description,
    skills: AI_ROLES[key].skills
  }));
  res.json(roles);
});

// 获取角色详情
app.get('/api/roles/:roleId', (req, res) => {
  const roleId = req.params.roleId;
  if (AI_ROLES[roleId]) {
    res.json(AI_ROLES[roleId]);
  } else {
    res.status(404).json({ error: '角色不存在' });
  }
});

// 搜索角色
app.get('/api/roles/search/:query', (req, res) => {
  const query = req.params.query.toLowerCase();
  const results = Object.keys(AI_ROLES)
    .filter(key => {
      const role = AI_ROLES[key];
      return role.name.toLowerCase().includes(query) ||
             role.description.toLowerCase().includes(query) ||
             role.skills.some(skill => skill.toLowerCase().includes(query));
    })
    .map(key => ({
      id: key,
      name: AI_ROLES[key].name,
      description: AI_ROLES[key].description,
      skills: AI_ROLES[key].skills
    }));
  res.json(results);
});

// 聊天接口
app.post('/api/chat', async (req, res) => {
  try {
    const { roleId, message, conversationId, modelType } = req.body;
    
    if (!AI_ROLES[roleId]) {
      return res.status(404).json({ error: '角色不存在' });
    }

    // 使用指定的模型或默认模型
    const selectedModel = modelType || CURRENT_MODEL;
    if (!MODEL_CONFIG[selectedModel]) {
      return res.status(400).json({ error: '不支持的模型类型' });
    }

    // 获取或创建对话历史
    const convId = conversationId || `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    if (!conversations.has(convId)) {
      conversations.set(convId, []);
    }
    
    const conversation = conversations.get(convId);
    
    // 构建消息历史
    const messages = [
      { role: 'system', content: AI_ROLES[roleId].systemPrompt },
      ...conversation,
      { role: 'user', content: message }
    ];

    // 调用聊天API
    const aiResponse = await callChatAPI(messages, selectedModel);
    
    // 更新对话历史
    conversation.push({ role: 'user', content: message });
    conversation.push({ role: 'assistant', content: aiResponse });
    
    // 限制对话历史长度
    if (conversation.length > 20) {
      conversation.splice(0, 2);
    }

    res.json({
      response: aiResponse,
      conversationId: convId,
      role: AI_ROLES[roleId],
      model: MODEL_CONFIG[selectedModel].name
    });

  } catch (error) {
    console.error('Chat error:', error);
    res.status(500).json({ error: error.message || '聊天服务暂时不可用' });
  }
});

// 角色技能展示
app.post('/api/roles/:roleId/skill', async (req, res) => {
  try {
    const { roleId } = req.params;
    const { skillType, modelType } = req.body;
    
    if (!AI_ROLES[roleId]) {
      return res.status(404).json({ error: '角色不存在' });
    }

    const role = AI_ROLES[roleId];
    const selectedModel = modelType || CURRENT_MODEL;
    let skillResponse = '';

    switch (skillType) {
      case 'demo':
        // 角色技能演示
        const demoPrompt = `作为${role.name}，请展示你的一个特殊技能。用一段简短的对话或展示来体现你的专长。`;
        const messages = [
          { role: 'system', content: role.systemPrompt },
          { role: 'user', content: demoPrompt }
        ];
        skillResponse = await callChatAPI(messages, selectedModel);
        break;
        
      case 'knowledge':
        // 知识问答
        skillResponse = `作为${role.name}，我可以与你分享我的专业知识。请问我任何相关的问题！`;
        break;
        
      case 'interaction':
        // 特殊互动
        skillResponse = `作为${role.name}，我有独特的互动方式。让我们开始一段有趣的对话吧！`;
        break;
    }

    res.json({
      skillResponse,
      skillType,
      role: role,
      model: MODEL_CONFIG[selectedModel].name
    });

  } catch (error) {
    console.error('Skill error:', error);
    res.status(500).json({ error: error.message || '技能展示暂时不可用' });
  }
});

// 简化版聊天界面
app.get('/simple', (req, res) => {
  res.sendFile(path.join(__dirname, 'simple-chat.html'));
});

// 测试页面
app.get('/test', (req, res) => {
  res.sendFile(path.join(__dirname, 'test.html'));
});

// 处理所有其他路由，返回HTML应用
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`服务器运行在 http://localhost:${PORT}`);
  console.log(`当前使用模型: ${MODEL_CONFIG[CURRENT_MODEL].name}`);
  console.log(`可用模型: ${Object.keys(MODEL_CONFIG).map(k => MODEL_CONFIG[k].name).join(', ')}`);
});
